package com.demo.java.OD251_300.OD280;

import java.util.Scanner;

/**
 * @author bug菌
 * @Source 公众号：猿圈奇妙屋
 * @des： 【上班之路】问题
 * @url： https://blog.csdn.net/weixin_43970743/article/details/146078826
 */
public class OdMain {
    private static final int[][] offsets = {{0, 1, 1}, {0, -1, 2}, {1, 0, 3}, {-1, 0, 4}}; // 右, 左, 下, 上 四个方向
    private static int max_turns;  // 最大转弯次数
    private static int max_clears;  // 最大清除障碍次数
    private static int num_rows;  // 地图行数
    private static int num_cols;  // 地图列数
    private static String[][] grid;  // 地图

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        max_turns = in.nextInt();  // 输入最大转弯次数
        max_clears = in.nextInt();  // 输入最大清除障碍次数
        num_rows = in.nextInt();  // 输入地图的行数
        num_cols = in.nextInt();  // 输入地图的列数
        grid = new String[num_rows][num_cols];  // 初始化地图
        for (int i = 0; i < num_rows; i++) {
            grid[i] = in.next().split("");  // 输入每行的地图内容
        }

        // 遍历地图，寻找起点 'S'
        for (int i = 0; i < num_rows; i++) {
            for (int j = 0; j < num_cols; j++) {
                boolean[][] is_visited = new boolean[num_rows][num_cols];  // 标记访问过的位置
                if ("S".equals(grid[i][j])) {  // 找到起点
                    // 从起点开始进行 DFS 搜索
                    if (dfs(is_visited, i, j, 0, 0, 0)) {
                        System.out.println("YES");  // 如果找到路径，则输出 YES
                        return;
                    } else {
                        System.out.println("NO");  // 如果没有路径，则输出 NO
                        return;
                    }
                }
            }
        }
        System.out.println("NO");  // 如果遍历完没有找到路径，输出 NO
    }

    // DFS 搜索函数
    private static boolean dfs(boolean[][] is_visited, int x, int y, int turns_used, int clears_used, int last_direction) {
        // 如果当前的位置是终点 'T'，返回 true
        if ("T".equals(grid[x][y])) {
            return true;
        }

        // 标记当前位置已访问
        is_visited[x][y] = true;

        // 遍历四个方向
        for (int[] offset : offsets) {
            int current_direction = offset[2];  // 当前方向
            int new_x = x + offset[0];  // 新的 x 坐标
            int new_y = y + offset[1];  // 新的 y 坐标
            boolean turn_flag = false;  // 是否需要转弯
            boolean break_flag = false;  // 是否遇到障碍物

            // 判断新的位置是否在地图范围内，且没有访问过
            if (new_x >= 0 && new_x < num_rows && new_y >= 0 && new_y < num_cols &&
                    !is_visited[new_x][new_y]) {

                // 如果转弯，则增加转弯次数
                if (last_direction != 0 && last_direction != current_direction) {
                    if (turns_used + 1 > max_turns) {
                        continue;  // 如果转弯次数超过最大限制，则跳过
                    }
                    turn_flag = true;
                }

                // 如果遇到障碍物，则增加清除次数
                if ("*".equals(grid[new_x][new_y])) {
                    if (clears_used + 1 > max_clears) {
                        continue;  // 如果清除次数超过最大限制，则跳过
                    }
                    break_flag = true;
                }

                // 递归调用 DFS，继续探索
                if (dfs(is_visited, new_x, new_y, turns_used + (turn_flag ? 1 : 0),
                        clears_used + (break_flag ? 1 : 0), current_direction)) {
                    return true;  // 如果找到路径，则返回 true
                }
            }
        }
        return false;  // 如果没有找到路径，则返回 false
    }
}